home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / idlelib / PyParse.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  9KB  |  391 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. import re
  5. import sys
  6. (C_NONE, C_BACKSLASH, C_STRING, C_BRACKET) = range(4)
  7. _synchre = re.compile('\n    ^\n    [ \\t]*\n    (?: if\n    |   for\n    |   while\n    |   else\n    |   def\n    |   return\n    |   assert\n    |   break\n    |   class\n    |   continue\n    |   elif\n    |   try\n    |   except\n    |   raise\n    |   import\n    |   yield\n    )\n    \\b\n', re.VERBOSE | re.MULTILINE).search
  8. _junkre = re.compile('\n    [ \\t]*\n    (?: \\# \\S .* )?\n    \\n\n', re.VERBOSE).match
  9. _match_stringre = re.compile('\n    \\""" [^"\\\\]* (?:\n                     (?: \\\\. | "(?!"") )\n                     [^"\\\\]*\n                 )*\n    (?: \\""" )?\n\n|   " [^"\\\\\\n]* (?: \\\\. [^"\\\\\\n]* )* "?\n\n|   \'\'\' [^\'\\\\]* (?:\n                   (?: \\\\. | \'(?!\'\') )\n                   [^\'\\\\]*\n                )*\n    (?: \'\'\' )?\n\n|   \' [^\'\\\\\\n]* (?: \\\\. [^\'\\\\\\n]* )* \'?\n', re.VERBOSE | re.DOTALL).match
  10. _itemre = re.compile('\n    [ \\t]*\n    [^\\s#\\\\]    # if we match, m.end()-1 is the interesting char\n', re.VERBOSE).match
  11. _closere = re.compile('\n    \\s*\n    (?: return\n    |   break\n    |   continue\n    |   raise\n    |   pass\n    )\n    \\b\n', re.VERBOSE).match
  12. _chew_ordinaryre = re.compile('\n    [^[\\](){}#\'"\\\\]+\n', re.VERBOSE).match
  13. _tran = [
  14.     'x'] * 256
  15. for ch in '({[':
  16.     _tran[ord(ch)] = '('
  17.  
  18. for ch in ')}]':
  19.     _tran[ord(ch)] = ')'
  20.  
  21. for ch in '"\'\\\n#':
  22.     _tran[ord(ch)] = ch
  23.  
  24. _tran = ''.join(_tran)
  25. del ch
  26.  
  27. try:
  28.     UnicodeType = type(unicode(''))
  29. except NameError:
  30.     UnicodeType = None
  31.  
  32.  
  33. class Parser:
  34.     
  35.     def __init__(self, indentwidth, tabwidth):
  36.         self.indentwidth = indentwidth
  37.         self.tabwidth = tabwidth
  38.  
  39.     
  40.     def set_str(self, str):
  41.         if type(str) is UnicodeType:
  42.             uniphooey = str
  43.             str = []
  44.             push = str.append
  45.             for raw in map(ord, uniphooey):
  46.                 if not raw < 127 or chr(raw):
  47.                     pass
  48.                 push('x')
  49.             
  50.             str = ''.join(str)
  51.         
  52.         self.str = str
  53.         self.study_level = 0
  54.  
  55.     
  56.     def find_good_parse_start(self, use_ps1, is_char_in_string = None, _synchre = _synchre):
  57.         str = self.str
  58.         pos = None
  59.         if use_ps1:
  60.             ps1 = '\n' + sys.ps1
  61.             i = str.rfind(ps1)
  62.             if i >= 0:
  63.                 pos = i + len(ps1)
  64.                 self.str = str[:pos - 1] + '\n' + str[pos:]
  65.             
  66.             return pos
  67.         
  68.         if not is_char_in_string:
  69.             return None
  70.         
  71.         limit = len(str)
  72.         for tries in range(5):
  73.             i = str.rfind(':\n', 0, limit)
  74.             if i < 0:
  75.                 break
  76.             
  77.             i = str.rfind('\n', 0, i) + 1
  78.             m = _synchre(str, i, limit)
  79.             if m and not is_char_in_string(m.start()):
  80.                 pos = m.start()
  81.                 break
  82.             
  83.             limit = i
  84.         
  85.         if pos is None:
  86.             m = _synchre(str)
  87.             if m and not is_char_in_string(m.start()):
  88.                 pos = m.start()
  89.             
  90.             return pos
  91.         
  92.         i = pos + 1
  93.         while None:
  94.             m = _synchre(str, i)
  95.             if m:
  96.                 (s, i) = m.span()
  97.                 if not is_char_in_string(s):
  98.                     pos = s
  99.                 
  100.             break
  101.         return pos
  102.  
  103.     
  104.     def set_lo(self, lo):
  105.         if lo > 0:
  106.             self.str = self.str[lo:]
  107.         
  108.  
  109.     
  110.     def _study1(self):
  111.         if self.study_level >= 1:
  112.             return None
  113.         
  114.         self.study_level = 1
  115.         str = self.str
  116.         str = str.translate(_tran)
  117.         str = str.replace('xxxxxxxx', 'x')
  118.         str = str.replace('xxxx', 'x')
  119.         str = str.replace('xx', 'x')
  120.         str = str.replace('xx', 'x')
  121.         str = str.replace('\nx', '\n')
  122.         continuation = C_NONE
  123.         level = lno = 0
  124.         self.goodlines = goodlines = [
  125.             0]
  126.         push_good = goodlines.append
  127.         i = 0
  128.         n = len(str)
  129.         while i < n:
  130.             ch = str[i]
  131.             i = i + 1
  132.             if ch == 'x':
  133.                 continue
  134.             
  135.             if ch == '\n':
  136.                 lno = lno + 1
  137.                 if level == 0:
  138.                     push_good(lno)
  139.                     continue
  140.                 continue
  141.             
  142.             if ch == '(':
  143.                 level = level + 1
  144.                 continue
  145.             
  146.             if ch == ')':
  147.                 if level:
  148.                     level = level - 1
  149.                     continue
  150.                 continue
  151.             
  152.             if ch == '"' or ch == "'":
  153.                 quote = ch
  154.                 if str[i - 1:i + 2] == quote * 3:
  155.                     quote = quote * 3
  156.                 
  157.                 w = len(quote) - 1
  158.                 i = i + w
  159.                 while i < n:
  160.                     ch = str[i]
  161.                     i = i + 1
  162.                     if ch == 'x':
  163.                         continue
  164.                     
  165.                     if str[i - 1:i + w] == quote:
  166.                         i = i + w
  167.                         break
  168.                     
  169.                     if ch == '\n':
  170.                         lno = lno + 1
  171.                         if w == 0:
  172.                             if level == 0:
  173.                                 push_good(lno)
  174.                             
  175.                             break
  176.                             continue
  177.                         continue
  178.                     
  179.                     if ch == '\\':
  180.                         if str[i] == '\n':
  181.                             lno = lno + 1
  182.                         
  183.                         i = i + 1
  184.                         continue
  185.                         continue
  186.                 continuation = C_STRING
  187.                 continue
  188.             
  189.             if ch == '#':
  190.                 i = str.find('\n', i)
  191.                 continue
  192.             
  193.             if str[i] == '\n':
  194.                 lno = lno + 1
  195.                 if i + 1 == n:
  196.                     continuation = C_BACKSLASH
  197.                 
  198.             
  199.             i = i + 1
  200.         if continuation != C_STRING and level > 0:
  201.             continuation = C_BRACKET
  202.         
  203.         self.continuation = continuation
  204.         if goodlines[-1] != lno:
  205.             push_good(lno)
  206.         
  207.  
  208.     
  209.     def get_continuation_type(self):
  210.         self._study1()
  211.         return self.continuation
  212.  
  213.     
  214.     def _study2(self):
  215.         if self.study_level >= 2:
  216.             return None
  217.         
  218.         self._study1()
  219.         self.study_level = 2
  220.         str = self.str
  221.         goodlines = self.goodlines
  222.         i = len(goodlines) - 1
  223.         p = len(str)
  224.         while i:
  225.             q = p
  226.             for nothing in range(goodlines[i - 1], goodlines[i]):
  227.                 p = str.rfind('\n', 0, p - 1) + 1
  228.             
  229.             if _junkre(str, p):
  230.                 i = i - 1
  231.                 continue
  232.             break
  233.         if i == 0:
  234.             q = p
  235.         
  236.         self.stmt_start = p
  237.         self.stmt_end = q
  238.         lastch = ''
  239.         stack = []
  240.         push_stack = stack.append
  241.         while p < q:
  242.             m = _chew_ordinaryre(str, p, q)
  243.             if m:
  244.                 newp = m.end()
  245.                 i = newp - 1
  246.                 while i >= p and str[i] in ' \t\n':
  247.                     i = i - 1
  248.                 if i >= p:
  249.                     lastch = str[i]
  250.                 
  251.                 p = newp
  252.                 if p >= q:
  253.                     break
  254.                 
  255.             
  256.             ch = str[p]
  257.             if ch in '([{':
  258.                 push_stack(p)
  259.                 lastch = ch
  260.                 p = p + 1
  261.                 continue
  262.             
  263.             if ch in ')]}':
  264.                 if stack:
  265.                     del stack[-1]
  266.                 
  267.                 lastch = ch
  268.                 p = p + 1
  269.                 continue
  270.             
  271.             if ch == '"' or ch == "'":
  272.                 lastch = ch
  273.                 p = _match_stringre(str, p, q).end()
  274.                 continue
  275.             
  276.             if ch == '#':
  277.                 p = str.find('\n', p, q) + 1
  278.                 continue
  279.             
  280.             p = p + 1
  281.             if str[p] != '\n':
  282.                 lastch = ch + str[p]
  283.             
  284.             p = p + 1
  285.         self.lastch = lastch
  286.         if stack:
  287.             self.lastopenbracketpos = stack[-1]
  288.         
  289.  
  290.     
  291.     def compute_bracket_indent(self):
  292.         self._study2()
  293.         j = self.lastopenbracketpos
  294.         str = self.str
  295.         n = len(str)
  296.         origi = i = str.rfind('\n', 0, j) + 1
  297.         j = j + 1
  298.         while j < n:
  299.             m = _itemre(str, j)
  300.             if m:
  301.                 j = m.end() - 1
  302.                 extra = 0
  303.                 break
  304.                 continue
  305.             i = j = str.find('\n', j) + 1
  306.         j = i = origi
  307.         while str[j] in ' \t':
  308.             j = j + 1
  309.         extra = self.indentwidth
  310.         return len(str[i:j].expandtabs(self.tabwidth)) + extra
  311.  
  312.     
  313.     def get_num_lines_in_stmt(self):
  314.         self._study1()
  315.         goodlines = self.goodlines
  316.         return goodlines[-1] - goodlines[-2]
  317.  
  318.     
  319.     def compute_backslash_indent(self):
  320.         self._study2()
  321.         str = self.str
  322.         i = self.stmt_start
  323.         while str[i] in ' \t':
  324.             i = i + 1
  325.         startpos = i
  326.         endpos = str.find('\n', startpos) + 1
  327.         found = level = 0
  328.         while i < endpos:
  329.             ch = str[i]
  330.             if ch in '([{':
  331.                 level = level + 1
  332.                 i = i + 1
  333.                 continue
  334.             if ch in ')]}':
  335.                 if level:
  336.                     level = level - 1
  337.                 
  338.                 i = i + 1
  339.                 continue
  340.             if ch == '"' or ch == "'":
  341.                 i = _match_stringre(str, i, endpos).end()
  342.                 continue
  343.             if ch == '#':
  344.                 break
  345.                 continue
  346.             if level == 0 and ch == '=':
  347.                 if (i == 0 or str[i - 1] not in '=<>!') and str[i + 1] != '=':
  348.                     found = 1
  349.                     break
  350.                     continue
  351.             i = i + 1
  352.         if found:
  353.             i = i + 1
  354.             found = re.match('\\s*\\\\', str[i:endpos]) is None
  355.         
  356.         if not found:
  357.             i = startpos
  358.             while str[i] not in ' \t\n':
  359.                 i = i + 1
  360.         
  361.         return len(str[self.stmt_start:i].expandtabs(self.tabwidth)) + 1
  362.  
  363.     
  364.     def get_base_indent_string(self):
  365.         self._study2()
  366.         i = self.stmt_start
  367.         n = self.stmt_end
  368.         j = i
  369.         str = self.str
  370.         while j < n and str[j] in ' \t':
  371.             j = j + 1
  372.         return str[i:j]
  373.  
  374.     
  375.     def is_block_opener(self):
  376.         self._study2()
  377.         return self.lastch == ':'
  378.  
  379.     
  380.     def is_block_closer(self):
  381.         self._study2()
  382.         return _closere(self.str, self.stmt_start) is not None
  383.  
  384.     lastopenbracketpos = None
  385.     
  386.     def get_last_open_bracket_pos(self):
  387.         self._study2()
  388.         return self.lastopenbracketpos
  389.  
  390.  
  391.